package com.tanhua.server.service;

import cn.hutool.core.collection.CollUtil;
import com.tanhua.dubbo.api.*;
import com.tanhua.model.domain.UserInfo;
import com.tanhua.model.dto.AnswersDto;
import com.tanhua.model.mongo.Questionnaire;
import com.tanhua.model.mongo.SoulRecommend;
import com.tanhua.model.mongo.SoulResult;
import com.tanhua.model.vo.*;
import com.tanhua.server.interceptor.UserHolder;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
import org.bson.types.ObjectId;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.*;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Service
public class TestSoulService {


    @DubboReference
    private QuestionsApi questionsApi;


    @DubboReference
    private QuestionnaireApi questionnaireApi;

    @DubboReference
    private UserInfoApi userInfoApi;

    @DubboReference
    private OptionApi optionApi;

    @DubboReference
    private SoulResultApi soulResultApi;

    @Value("${tanhua.test.con.soul}")
    private String recommendUser;



    public List<SoulQuestionnaireVo> testSoul() {
        // 获得当前登陆的用户ID
        Long userId = UserHolder.getUserId();
        // 获取当前登陆的时间
        String data = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        List<SoulQuestionnaireVo> questionnaireVoList = new ArrayList<>();
        // 查看是否存在灵魂报告
        List<SoulResult> soulResultList = questionnaireApi.checkHistory(userId, data);
        List<SoulRecommend> soulRecommendList = questionnaireApi.getRecommendStar(userId);
        // 遍历循环
        for (int i = 1; i <= 3; i++) {
            // 构建一个vo
            SoulQuestionnaireVo soulQuestionnaireVo = new SoulQuestionnaireVo();
            soulQuestionnaireVo.setId(String.valueOf(i));
            Questionnaire questionnaire = new Questionnaire();
            if(i==1){
                questionnaire = questionnaireApi.prepareQuestionnaire(i, 2);
                BeanUtils.copyProperties(questionnaire, soulQuestionnaireVo);
            }else if(i==2){
                questionnaire = questionnaireApi.prepareQuestionnaire(i, 3);
                BeanUtils.copyProperties(questionnaire, soulQuestionnaireVo);
            }else {
                questionnaire = questionnaireApi.prepareQuestionnaire(i, 5);
                BeanUtils.copyProperties(questionnaire, soulQuestionnaireVo);
            }
            soulQuestionnaireVo.setLevel(questionnaire.getLevel());
            // 是否锁住（0解锁，1锁住）
            if (i <= soulResultList.size() + 1) {
                List<SoulQuestionsVo> soulQuestionsVoList = questionnaireApi.prepareQuestions(questionnaire.getQId());
                soulQuestionnaireVo.setQuestions(soulQuestionsVoList);
                soulQuestionnaireVo.setIsLock(0);
                if (i <= soulResultList.size()) {
                    soulQuestionnaireVo.setReportId(soulResultList.get(i - 1).getId().toHexString());
                } else {
                    soulQuestionnaireVo.setReportId(null);
                }
            } else {
                soulQuestionnaireVo.setIsLock(1);
                soulQuestionnaireVo.setReportId(null);
                soulQuestionnaireVo.setQuestions(null);
            }
            // 构建vo
            questionnaireVoList.add(soulQuestionnaireVo);
        }
        return questionnaireVoList;
    }

    /**
     * 查看灵魂测试结果
     *
     * @param id // 2 .根据当前的登陆的查询userinfo表查询出用户的详细信息
     *           UserInfo userInfo = userInfoApi.findById(UserHolder.getUserId());
     * @return
     */
    public SoulResultVo<Object> findSurveyResults(ObjectId id) {
        // 获得当前登陆的用户ID
        Long userId = UserHolder.getUserId();
        // 根据报告单的ID查询数据库 查询出报告单的数据
        SoulResult soulResult = soulResultApi.findById(id);
        // 在根据用户的分值返回conclusion
        Integer score = soulResult.getScore();
        SoulResultVo<Object> vo = new SoulResultVo<>();
        vo.setConclusion(soulResult.getConclusion());
        vo.setCover(soulResult.getCover());

        // 维度
        // 枚举: 外向,判断,抽象,理性
        // 维度值 枚举: 80%,70%,90%,60%
        List<Object> vos = new ArrayList<>();
        Dimensions dimensions = new Dimensions();
        dimensions.setKey(soulResult.getOutgoing());
        dimensions.setValue("80%");
        vos.add(dimensions);
        Dimensions dimensions1 = new Dimensions();
        dimensions1.setKey(soulResult.getJudge());
        dimensions1.setValue("70%");
        vos.add(dimensions1);
        Dimensions dimensions2 = new Dimensions();
        dimensions2.setKey(soulResult.getAbstraction());
        dimensions2.setValue("60%");
        vos.add(dimensions2);
        Dimensions dimensions3 = new Dimensions();
        dimensions3.setKey(soulResult.getReason());
        dimensions3.setValue("50%");
        vos.add(dimensions3);


        vo.setDimensions(vos);
        // 查询分数与你想近的人 10条 用户的编号 和头像
        // 查询不到给一个默认值
        List<Long> ids = soulResultApi.findByScore(score, userId);
        if (CollUtil.isEmpty(ids)) {
            String[] userIdS = recommendUser.split(",");
            ids = Arrays.stream(userIdS).map(k -> Long.valueOf(k))
                    .collect(Collectors.toList());
        }
        Map<Long, UserInfo> map = userInfoApi.findByIds(ids, null);
        List<Object> voss = new ArrayList<>();
        for (Long aLong : ids) {
            UserInfo userInfo = map.get(aLong);
            SimilarYouVo similarYouVo = new SimilarYouVo();
            BeanUtils.copyProperties(userInfo, similarYouVo);
            voss.add(similarYouVo);
        }
        vo.setSimilarYou(voss);
        return vo;
    }

    /**
     * 提交问卷
     *
     * @param answersDtos
     * @return
     */
    public String submitSoul(List<AnswersDto> answersDtos) {
        // 1.遍历list集合拿到问卷的试题编号
        String questionId = "";
        List<ObjectId> ids = new ArrayList<>();
        for (AnswersDto answersDto : answersDtos) {
            ids.add(new ObjectId(answersDto.getOptionId()));
            questionId = answersDto.getQuestionId();
        }
        // 2.计算数据的分值
        Integer score = optionApi.scoreNumber(ids);
        // 3.为属性赋值
        // 4.报告单ID 为当前的时间年月日加上当前用户的用户的ID
        String data = new SimpleDateFormat("yyyyMMdd").format(new Date());
        SoulResult soulResultInfo = soulResultApi.findByReportId(data + UserHolder.getUserId());
        ObjectId id  = null;
        if (soulResultInfo == null) {
            SoulResult soulResult = getSoulResult(questionId, score, data);
            //保存
             id = soulResultApi.save(soulResult);
        } else if (soulResultInfo.getLevel().equals("初级")){
            SoulResult soulResult = getSoulResult(questionId, score, data);
            id = soulResultApi.save(soulResult);
        }else if (soulResultInfo.getLevel().equals("中级")) {
            SoulResult soulResult = getSoulResult(questionId, score, data);
            //保存
            id = soulResultApi.save(soulResult);
        }else {
            // 存在进行更新
            extracted(score, soulResultInfo);
            if("10".equals(questionId)){
                soulResultInfo.setLevel("初级");
            }else if("20".equals(questionId)){
                soulResultInfo.setLevel("中级");
            }else {
                soulResultInfo.setLevel("高级");
            }
            soulResultInfo.setScore(score);
            id = soulResultApi.updata(soulResultInfo);
        }
        // 4.构造返回总分 报告单的ID
        return id.toHexString();
    }

    private SoulResult getSoulResult(String questionId, Integer score, String data) {
        SoulResult soulResult = new SoulResult();
        Long userId = UserHolder.getUserId();
        String res = data + userId;
        // 不存在进行新增
        soulResult.setReportId(res);
        extracted(score, soulResult);
        String data1 = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        soulResult.setDate(data1);
        soulResult.setUserId(UserHolder.getUserId());
        if ("10".equals(questionId)) {
            soulResult.setLevel("初级");
        } else if ("20".equals(questionId)) {
            soulResult.setLevel("中级");
        } else {
            soulResult.setLevel("高级");
        }
        soulResult.setOutgoing("外向");
        soulResult.setJudge("判断");
        soulResult.setAbstraction("抽象");
        soulResult.setReason("理性");
        soulResult.setScore(score);
        //保存
        return soulResult;
    }

    private void extracted(Integer score, SoulResult soulResult) {
        if (score <= 30) {
            soulResult.setConclusion("猫头鹰：他们的共同特质为重计划、条理、细节精准。在行为上，表现出喜欢理性思考与分析、较重视制度、" +
                    "结构、规范。他们注重执行游戏规则、循规蹈矩、巨细靡遗、重视品质、敬业负责。");
            // 返回鉴定的图片
            soulResult.setCover("https://tanhua-dev.oss-cn-zhangjiakou.aliyuncs.com/images/test_soul/owl.png");
        } else if (score > 30 && score <= 40) {
            soulResult.setConclusion("白兔型：平易近人、敦厚可靠、避免冲突与不具批判性。在行为上，表现出不慌不忙、冷静自持的态度。" +
                    "他们注重稳定与中长程规划，现实生活中，常会反思自省并以和谐为中心，即使面对困境，亦能泰然自若，从容应付。");
            // 返回鉴定的图片
            soulResult.setCover("https://tanhua-dev.oss-cn-zhangjiakou.aliyuncs.com/images/test_soul/rabbit.png");
        } else if (score > 40 && score <= 50) {
            soulResult.setConclusion("狐狸型 ：人际关系能力极强，擅长以口语表达感受而引起共鸣，很会激励并带动气氛。" +
                    "他们喜欢跟别人互动，重视群体的归属感，基本上是比较「人际导向」。由于他们富同理心并乐于分享，具有很好的亲和力，在服务业、销售业、传播业及公共关系等领域中，狐狸型的领导者都有很杰出的表现。");
            // 返回鉴定的图片
            soulResult.setCover("https://tanhua-dev.oss-cn-zhangjiakou.aliyuncs.com/images/test_soul/fox.png");
        } else {
            soulResult.setConclusion("狮子型：性格为充满自信、竞争心强、主动且企图心强烈，是个有决断力的领导者。一般而言，狮子型的人胸怀大志，勇于冒险，看问题能够直指核心，并对目标全力以赴。" +
                    "他们在领导风格及决策上，强调权威与果断，擅长危机处理，此种性格最适合开创性与改革性的工作。");
            // 返回鉴定的图片
            soulResult.setCover("https://tanhua-dev.oss-cn-zhangjiakou.aliyuncs.com/images/test_soul/lion.png");
        }
    }
}
